home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 June / PersonalComputerWorld-June2009-CoverdiscCD.iso / Software / Freeware / Adobe AIR 1.5.1 / AdobeAIRInstaller.exe / setup.swf / scripts / mx / controls / ProgressBar.as < prev    next >
Encoding:
Text File  |  2009-02-12  |  28.5 KB  |  867 lines
  1. package mx.controls
  2. {
  3.    import flash.display.DisplayObject;
  4.    import flash.display.Graphics;
  5.    import flash.events.Event;
  6.    import flash.events.IEventDispatcher;
  7.    import flash.events.ProgressEvent;
  8.    import flash.events.TimerEvent;
  9.    import flash.text.TextLineMetrics;
  10.    import flash.utils.Timer;
  11.    import mx.core.FlexVersion;
  12.    import mx.core.IFlexDisplayObject;
  13.    import mx.core.IFlexModuleFactory;
  14.    import mx.core.IFontContextComponent;
  15.    import mx.core.IUITextField;
  16.    import mx.core.UIComponent;
  17.    import mx.core.UITextField;
  18.    import mx.core.mx_internal;
  19.    import mx.styles.ISimpleStyleClient;
  20.    
  21.    use namespace mx_internal;
  22.    
  23.    public class ProgressBar extends UIComponent implements IFontContextComponent
  24.    {
  25.       mx_internal static const VERSION:String = "3.0.0.0";
  26.       
  27.       private var _direction:String = "right";
  28.       
  29.       private var stopPolledMode:Boolean = false;
  30.       
  31.       mx_internal var _labelField:IUITextField;
  32.       
  33.       mx_internal var _determinateBar:IFlexDisplayObject;
  34.       
  35.       private var sourceChanged:Boolean = false;
  36.       
  37.       private var _interval:Number = 30;
  38.       
  39.       private var trackSkinChanged:Boolean = false;
  40.       
  41.       mx_internal var _content:UIComponent;
  42.       
  43.       private var _source:Object;
  44.       
  45.       mx_internal var _track:IFlexDisplayObject;
  46.       
  47.       mx_internal var _bar:UIComponent;
  48.       
  49.       mx_internal var _barMask:IFlexDisplayObject;
  50.       
  51.       private var barSkinChanged:Boolean = false;
  52.       
  53.       private var _stringSource:String;
  54.       
  55.       private var _labelPlacement:String = "bottom";
  56.       
  57.       private var _value:Number = 0;
  58.       
  59.       private var indeterminateChanged:Boolean = true;
  60.       
  61.       private var _mode:String = "event";
  62.       
  63.       private var stringSourceChanged:Boolean = false;
  64.       
  65.       private var modeChanged:Boolean = false;
  66.       
  67.       private var _conversion:Number = 1;
  68.       
  69.       mx_internal var _indeterminateBar:IFlexDisplayObject;
  70.       
  71.       private var indeterminateSkinChanged:Boolean = false;
  72.       
  73.       private var _indeterminate:Boolean = false;
  74.       
  75.       private var pollTimer:Timer;
  76.       
  77.       private var _minimum:Number = 0;
  78.       
  79.       private var labelOverride:String;
  80.       
  81.       private var _maximum:Number = 0;
  82.       
  83.       private var visibleChanged:Boolean = false;
  84.       
  85.       private var indeterminatePlaying:Boolean = false;
  86.       
  87.       private var _label:String;
  88.       
  89.       public function ProgressBar()
  90.       {
  91.          super();
  92.          pollTimer = new Timer(_interval);
  93.          cacheAsBitmap = true;
  94.       }
  95.       
  96.       [Bindable("minimumChanged")]
  97.       public function get minimum() : Number
  98.       {
  99.          return _minimum;
  100.       }
  101.       
  102.       [Bindable("conversionChanged")]
  103.       public function get conversion() : Number
  104.       {
  105.          return _conversion;
  106.       }
  107.       
  108.       private function completeHandler(param1:Event) : void
  109.       {
  110.          dispatchEvent(param1);
  111.          invalidateDisplayList();
  112.       }
  113.       
  114.       [Bindable("sourceChanged")]
  115.       public function get source() : Object
  116.       {
  117.          return _source;
  118.       }
  119.       
  120.       public function set minimum(param1:Number) : void
  121.       {
  122.          if(!isNaN(param1) && _mode == ProgressBarMode.MANUAL && param1 != _minimum)
  123.          {
  124.             _minimum = param1;
  125.             invalidateDisplayList();
  126.             dispatchEvent(new Event("minimumChanged"));
  127.          }
  128.       }
  129.       
  130.       [Bindable("maximumChanged")]
  131.       public function get maximum() : Number
  132.       {
  133.          return _maximum;
  134.       }
  135.       
  136.       override protected function createChildren() : void
  137.       {
  138.          var _loc1_:Class = null;
  139.          super.createChildren();
  140.          if(!mx_internal::_content)
  141.          {
  142.             mx_internal::_content = new UIComponent();
  143.             addChild(mx_internal::_content);
  144.          }
  145.          if(!mx_internal::_bar)
  146.          {
  147.             mx_internal::_bar = new UIComponent();
  148.             mx_internal::_content.addChild(mx_internal::_bar);
  149.          }
  150.          if(!mx_internal::_barMask)
  151.          {
  152.             if(FlexVersion.compatibilityVersion >= FlexVersion.VERSION_3_0)
  153.             {
  154.                _loc1_ = getStyle("maskSkin");
  155.                mx_internal::_barMask = new _loc1_();
  156.             }
  157.             else
  158.             {
  159.                mx_internal::_barMask = new UIComponent();
  160.             }
  161.             mx_internal::_barMask.visible = true;
  162.             mx_internal::_bar.addChild(DisplayObject(mx_internal::_barMask));
  163.             UIComponent(mx_internal::_bar).mask = DisplayObject(mx_internal::_barMask);
  164.          }
  165.          if(!mx_internal::_labelField)
  166.          {
  167.             mx_internal::_labelField = IUITextField(createInFontContext(UITextField));
  168.             mx_internal::_labelField.styleName = this;
  169.             addChild(DisplayObject(mx_internal::_labelField));
  170.          }
  171.       }
  172.       
  173.       public function set source(param1:Object) : void
  174.       {
  175.          var value:Object = param1;
  176.          if(value is String)
  177.          {
  178.             _stringSource = String(value);
  179.             try
  180.             {
  181.                value = document[_stringSource];
  182.             }
  183.             catch(e:Error)
  184.             {
  185.                stringSourceChanged = true;
  186.             }
  187.          }
  188.          if(value)
  189.          {
  190.             _source = value;
  191.             sourceChanged = true;
  192.             modeChanged = true;
  193.             indeterminateChanged = true;
  194.             invalidateProperties();
  195.             invalidateDisplayList();
  196.          }
  197.          else if(_source != null)
  198.          {
  199.             _source = null;
  200.             sourceChanged = true;
  201.             indeterminateChanged = true;
  202.             invalidateProperties();
  203.             invalidateDisplayList();
  204.             pollTimer.reset();
  205.          }
  206.       }
  207.       
  208.       public function set conversion(param1:Number) : void
  209.       {
  210.          if(!isNaN(param1) && Number(param1) > 0 && param1 != _conversion)
  211.          {
  212.             _conversion = Number(param1);
  213.             invalidateDisplayList();
  214.             dispatchEvent(new Event("conversionChanged"));
  215.          }
  216.       }
  217.       
  218.       public function set maximum(param1:Number) : void
  219.       {
  220.          if(!isNaN(param1) && _mode == ProgressBarMode.MANUAL && param1 != _maximum)
  221.          {
  222.             _maximum = param1;
  223.             invalidateDisplayList();
  224.             dispatchEvent(new Event("maximumChanged"));
  225.          }
  226.       }
  227.       
  228.       public function set mode(param1:String) : void
  229.       {
  230.          if(param1 != _mode)
  231.          {
  232.             if(_mode == ProgressBarMode.POLLED)
  233.             {
  234.                stopPolledMode = true;
  235.             }
  236.             _mode = param1;
  237.             modeChanged = true;
  238.             indeterminateChanged = true;
  239.             invalidateProperties();
  240.             invalidateDisplayList();
  241.          }
  242.       }
  243.       
  244.       private function stopPlayingIndeterminate() : void
  245.       {
  246.          if(indeterminatePlaying)
  247.          {
  248.             indeterminatePlaying = false;
  249.             pollTimer.removeEventListener(TimerEvent.TIMER,updateIndeterminateHandler);
  250.             if(_mode != ProgressBarMode.POLLED)
  251.             {
  252.                pollTimer.reset();
  253.             }
  254.          }
  255.       }
  256.       
  257.       [Bindable("labelPlacementChanged")]
  258.       public function get labelPlacement() : String
  259.       {
  260.          return _labelPlacement;
  261.       }
  262.       
  263.       private function progressHandler(param1:ProgressEvent) : void
  264.       {
  265.          _setProgress(param1.bytesLoaded,param1.bytesTotal);
  266.       }
  267.       
  268.       override protected function measure() : void
  269.       {
  270.          var _loc1_:Number = NaN;
  271.          var _loc2_:Number = NaN;
  272.          super.measure();
  273.          var _loc3_:Number = NaN;
  274.          var _loc4_:Number = NaN;
  275.          var _loc5_:Number = getStyle("trackHeight");
  276.          var _loc6_:Number = Number(mx_internal::_track.measuredWidth);
  277.          var _loc7_:Number = isNaN(_loc5_) ? Number(mx_internal::_track.measuredHeight) : _loc5_;
  278.          var _loc8_:Number = getStyle("horizontalGap");
  279.          var _loc9_:Number = getStyle("verticalGap");
  280.          var _loc10_:Number = getStyle("paddingLeft");
  281.          var _loc11_:Number = getStyle("paddingRight");
  282.          var _loc12_:Number = getStyle("paddingTop");
  283.          var _loc13_:Number = getStyle("paddingBottom");
  284.          var _loc14_:Number = getStyle("labelWidth");
  285.          var _loc15_:TextLineMetrics = measureText(predictLabelText());
  286.          var _loc16_:Number = isNaN(_loc14_) ? _loc15_.width + UITextField.mx_internal::TEXT_WIDTH_PADDING : _loc14_;
  287.          var _loc17_:Number = _loc15_.height + UITextField.mx_internal::TEXT_HEIGHT_PADDING;
  288.          switch(labelPlacement)
  289.          {
  290.             case ProgressBarLabelPlacement.LEFT:
  291.             case ProgressBarLabelPlacement.RIGHT:
  292.                _loc1_ = _loc16_ + _loc6_ + _loc10_ + _loc11_ + _loc8_;
  293.                _loc2_ = Math.max(_loc17_,_loc7_) + _loc12_ + _loc13_;
  294.                measuredMinWidth = _loc1_;
  295.                break;
  296.             case ProgressBarLabelPlacement.CENTER:
  297.                _loc1_ = Math.max(_loc16_,_loc6_) + _loc10_ + _loc11_ + _loc8_;
  298.                _loc2_ = Math.max(_loc17_,_loc7_) + _loc12_ + _loc13_;
  299.                measuredMinWidth = _loc16_;
  300.                break;
  301.             default:
  302.                _loc1_ = Math.max(_loc16_,_loc6_) + _loc10_ + _loc11_;
  303.                _loc2_ = _loc17_ + _loc7_ + _loc12_ + _loc13_ + _loc9_;
  304.                measuredMinWidth = _loc16_;
  305.          }
  306.          measuredWidth = _loc1_;
  307.          measuredMinHeight = measuredHeight = _loc2_;
  308.          if(!isNaN(_loc3_))
  309.          {
  310.             measuredMinWidth = _loc3_;
  311.          }
  312.          if(!isNaN(_loc4_))
  313.          {
  314.             measuredMinHeight = _loc4_;
  315.          }
  316.       }
  317.       
  318.       public function get fontContext() : IFlexModuleFactory
  319.       {
  320.          return moduleFactory;
  321.       }
  322.       
  323.       private function predictLabelText() : String
  324.       {
  325.          var _loc2_:Number = NaN;
  326.          if(label == null)
  327.          {
  328.             return "";
  329.          }
  330.          var _loc1_:String = label;
  331.          if(_maximum != 0)
  332.          {
  333.             _loc2_ = _maximum;
  334.          }
  335.          else
  336.          {
  337.             _loc2_ = 100000;
  338.          }
  339.          if(_loc1_)
  340.          {
  341.             if(_indeterminate)
  342.             {
  343.                _loc1_ = _loc1_.replace("%1",String(Math.floor(_loc2_ / _conversion)));
  344.                _loc1_ = _loc1_.replace("%2","??");
  345.                _loc1_ = _loc1_.replace("%3","");
  346.                _loc1_ = _loc1_.replace("%%","");
  347.             }
  348.             else
  349.             {
  350.                _loc1_ = _loc1_.replace("%1",String(Math.floor(_loc2_ / _conversion)));
  351.                _loc1_ = _loc1_.replace("%2",String(Math.floor(_loc2_ / _conversion)));
  352.                _loc1_ = _loc1_.replace("%3","100");
  353.                _loc1_ = _loc1_.replace("%%","%");
  354.             }
  355.          }
  356.          var _loc3_:String = getFullLabelText();
  357.          if(_loc1_.length > _loc3_.length)
  358.          {
  359.             return _loc1_;
  360.          }
  361.          return _loc3_;
  362.       }
  363.       
  364.       [Bindable("change")]
  365.       public function get value() : Number
  366.       {
  367.          return _value;
  368.       }
  369.       
  370.       public function set indeterminate(param1:Boolean) : void
  371.       {
  372.          _indeterminate = param1;
  373.          indeterminateChanged = true;
  374.          invalidateProperties();
  375.          invalidateDisplayList();
  376.          dispatchEvent(new Event("indeterminateChanged"));
  377.       }
  378.       
  379.       private function createBar() : void
  380.       {
  381.          if(mx_internal::_determinateBar)
  382.          {
  383.             mx_internal::_bar.removeChild(DisplayObject(mx_internal::_determinateBar));
  384.             mx_internal::_determinateBar = null;
  385.          }
  386.          var _loc1_:Class = getStyle("barSkin");
  387.          if(_loc1_)
  388.          {
  389.             mx_internal::_determinateBar = new _loc1_();
  390.             if(mx_internal::_determinateBar is ISimpleStyleClient)
  391.             {
  392.                ISimpleStyleClient(mx_internal::_determinateBar).styleName = this;
  393.             }
  394.             mx_internal::_bar.addChild(DisplayObject(mx_internal::_determinateBar));
  395.          }
  396.       }
  397.       
  398.       private function createIndeterminateBar() : void
  399.       {
  400.          if(mx_internal::_indeterminateBar)
  401.          {
  402.             mx_internal::_bar.removeChild(DisplayObject(mx_internal::_indeterminateBar));
  403.             mx_internal::_indeterminateBar = null;
  404.          }
  405.          var _loc1_:Class = getStyle("indeterminateSkin");
  406.          if(_loc1_)
  407.          {
  408.             mx_internal::_indeterminateBar = new _loc1_();
  409.             if(mx_internal::_indeterminateBar is ISimpleStyleClient)
  410.             {
  411.                ISimpleStyleClient(mx_internal::_indeterminateBar).styleName = this;
  412.             }
  413.             mx_internal::_indeterminateBar.visible = false;
  414.             mx_internal::_bar.addChild(DisplayObject(mx_internal::_indeterminateBar));
  415.          }
  416.       }
  417.       
  418.       [Bindable("directionChanged")]
  419.       public function get direction() : String
  420.       {
  421.          return _direction;
  422.       }
  423.       
  424.       private function updatePolledHandler(param1:Event) : void
  425.       {
  426.          var _loc2_:Object = null;
  427.          var _loc3_:Number = NaN;
  428.          var _loc4_:Number = NaN;
  429.          if(_source)
  430.          {
  431.             _loc2_ = _source;
  432.             _loc3_ = Number(_loc2_.bytesLoaded);
  433.             _loc4_ = Number(_loc2_.bytesTotal);
  434.             if(!isNaN(_loc3_) && !isNaN(_loc4_))
  435.             {
  436.                _setProgress(_loc3_,_loc4_);
  437.                if(percentComplete >= 100 && _value > 0)
  438.                {
  439.                   pollTimer.reset();
  440.                }
  441.             }
  442.          }
  443.       }
  444.       
  445.       private function updateIndeterminateHandler(param1:Event) : void
  446.       {
  447.          if(mx_internal::_indeterminateBar.x < 1)
  448.          {
  449.             mx_internal::_indeterminateBar.x += 1;
  450.          }
  451.          else
  452.          {
  453.             mx_internal::_indeterminateBar.x = -(getStyle("indeterminateMoveInterval") - 2);
  454.          }
  455.       }
  456.       
  457.       public function set labelPlacement(param1:String) : void
  458.       {
  459.          if(param1 != _labelPlacement)
  460.          {
  461.             _labelPlacement = param1;
  462.          }
  463.          invalidateSize();
  464.          invalidateDisplayList();
  465.          dispatchEvent(new Event("labelPlacementChanged"));
  466.       }
  467.       
  468.       [Bindable("modeChanged")]
  469.       public function get mode() : String
  470.       {
  471.          return _mode;
  472.       }
  473.       
  474.       [Bindable("progress")]
  475.       public function get percentComplete() : Number
  476.       {
  477.          if(_value < _minimum || _maximum < _minimum)
  478.          {
  479.             return 0;
  480.          }
  481.          if(_maximum - _minimum == 0)
  482.          {
  483.             return 0;
  484.          }
  485.          var _loc1_:Number = 100 * (_value - _minimum) / (_maximum - _minimum);
  486.          if(isNaN(_loc1_) || _loc1_ < 0)
  487.          {
  488.             return 0;
  489.          }
  490.          if(_loc1_ > 100)
  491.          {
  492.             return 100;
  493.          }
  494.          return _loc1_;
  495.       }
  496.       
  497.       public function setProgress(param1:Number, param2:Number) : void
  498.       {
  499.          if(_mode == ProgressBarMode.MANUAL)
  500.          {
  501.             _setProgress(param1,param2);
  502.          }
  503.       }
  504.       
  505.       private function createTrack() : void
  506.       {
  507.          if(mx_internal::_track)
  508.          {
  509.             mx_internal::_content.removeChild(DisplayObject(mx_internal::_track));
  510.             mx_internal::_track = null;
  511.          }
  512.          var _loc1_:Class = getStyle("trackSkin");
  513.          if(_loc1_)
  514.          {
  515.             mx_internal::_track = new _loc1_();
  516.             if(mx_internal::_track is ISimpleStyleClient)
  517.             {
  518.                ISimpleStyleClient(mx_internal::_track).styleName = this;
  519.             }
  520.             mx_internal::_content.addChildAt(DisplayObject(mx_internal::_track),0);
  521.          }
  522.       }
  523.       
  524.       [Bindable("indeterminateChanged")]
  525.       public function get indeterminate() : Boolean
  526.       {
  527.          return _indeterminate;
  528.       }
  529.       
  530.       private function startPlayingIndeterminate() : void
  531.       {
  532.          if(!indeterminatePlaying)
  533.          {
  534.             indeterminatePlaying = true;
  535.             pollTimer.addEventListener(TimerEvent.TIMER,updateIndeterminateHandler,false,0,true);
  536.             pollTimer.start();
  537.          }
  538.       }
  539.       
  540.       override public function styleChanged(param1:String) : void
  541.       {
  542.          var _loc2_:Boolean = false;
  543.          super.styleChanged(param1);
  544.          if(param1 == null || param1 == "styleName")
  545.          {
  546.             barSkinChanged = trackSkinChanged = indeterminateSkinChanged = true;
  547.             _loc2_ = true;
  548.          }
  549.          else if(param1 == "barSkin")
  550.          {
  551.             barSkinChanged = true;
  552.             _loc2_ = true;
  553.          }
  554.          else if(param1 == "trackSkin")
  555.          {
  556.             trackSkinChanged = true;
  557.             _loc2_ = true;
  558.          }
  559.          else if(param1 == "indeterminateSkin")
  560.          {
  561.             indeterminateSkinChanged = true;
  562.             _loc2_ = true;
  563.          }
  564.          if(_loc2_)
  565.          {
  566.             invalidateProperties();
  567.             invalidateSize();
  568.             invalidateDisplayList();
  569.          }
  570.       }
  571.       
  572.       private function getFullLabelText() : String
  573.       {
  574.          var _loc1_:Number = Math.max(_value,0);
  575.          var _loc2_:Number = Math.max(_maximum,0);
  576.          var _loc3_:String = label;
  577.          if(_loc3_)
  578.          {
  579.             if(_indeterminate)
  580.             {
  581.                _loc3_ = _loc3_.replace("%1",String(Math.floor(_loc1_ / _conversion)));
  582.                _loc3_ = _loc3_.replace("%2","??");
  583.                _loc3_ = _loc3_.replace("%3","");
  584.                _loc3_ = _loc3_.replace("%%","");
  585.             }
  586.             else
  587.             {
  588.                _loc3_ = _loc3_.replace("%1",String(Math.floor(_loc1_ / _conversion)));
  589.                _loc3_ = _loc3_.replace("%2",String(Math.floor(_loc2_ / _conversion)));
  590.                _loc3_ = _loc3_.replace("%3",String(Math.floor(percentComplete)));
  591.                _loc3_ = _loc3_.replace("%%","%");
  592.             }
  593.          }
  594.          return _loc3_;
  595.       }
  596.       
  597.       override protected function commitProperties() : void
  598.       {
  599.          var index:int = 0;
  600.          super.commitProperties();
  601.          if(hasFontContextChanged() && mx_internal::_labelField != null)
  602.          {
  603.             index = getChildIndex(DisplayObject(mx_internal::_labelField));
  604.             removeChild(DisplayObject(mx_internal::_labelField));
  605.             mx_internal::_labelField = IUITextField(createInFontContext(UITextField));
  606.             mx_internal::_labelField.styleName = this;
  607.             addChildAt(DisplayObject(mx_internal::_labelField),index);
  608.          }
  609.          if(trackSkinChanged)
  610.          {
  611.             trackSkinChanged = false;
  612.             createTrack();
  613.          }
  614.          if(barSkinChanged)
  615.          {
  616.             barSkinChanged = false;
  617.             createBar();
  618.          }
  619.          if(indeterminateSkinChanged)
  620.          {
  621.             indeterminateSkinChanged = false;
  622.             createIndeterminateBar();
  623.          }
  624.          if(stringSourceChanged)
  625.          {
  626.             stringSourceChanged = false;
  627.             try
  628.             {
  629.                _source = document[_stringSource];
  630.             }
  631.             catch(e:Error)
  632.             {
  633.             }
  634.          }
  635.          if(sourceChanged)
  636.          {
  637.             sourceChanged = false;
  638.             dispatchEvent(new Event("sourceChanged"));
  639.          }
  640.          if(modeChanged)
  641.          {
  642.             modeChanged = false;
  643.             if(_source)
  644.             {
  645.                if(_mode == ProgressBarMode.EVENT)
  646.                {
  647.                   if(_source is IEventDispatcher)
  648.                   {
  649.                      _source.addEventListener(ProgressEvent.PROGRESS,progressHandler);
  650.                      _source.addEventListener(Event.COMPLETE,completeHandler);
  651.                   }
  652.                   else
  653.                   {
  654.                      _source = null;
  655.                   }
  656.                }
  657.                else
  658.                {
  659.                   _source.removeEventListener(ProgressEvent.PROGRESS,progressHandler);
  660.                   _source.removeEventListener(Event.COMPLETE,completeHandler);
  661.                }
  662.             }
  663.             if(_mode == ProgressBarMode.POLLED)
  664.             {
  665.                pollTimer.addEventListener(TimerEvent.TIMER,updatePolledHandler,false,0,true);
  666.                pollTimer.start();
  667.             }
  668.             else if(stopPolledMode)
  669.             {
  670.                stopPolledMode = false;
  671.                pollTimer.removeEventListener(TimerEvent.TIMER,updatePolledHandler);
  672.                pollTimer.reset();
  673.             }
  674.             dispatchEvent(new Event("modeChanged"));
  675.          }
  676.       }
  677.       
  678.       override protected function resourcesChanged() : void
  679.       {
  680.          super.resourcesChanged();
  681.          label = labelOverride;
  682.       }
  683.       
  684.       public function set fontContext(param1:IFlexModuleFactory) : void
  685.       {
  686.          this.moduleFactory = param1;
  687.       }
  688.       
  689.       override public function set visible(param1:Boolean) : void
  690.       {
  691.          super.visible = param1;
  692.          visibleChanged = true;
  693.          invalidateDisplayList();
  694.       }
  695.       
  696.       public function set label(param1:String) : void
  697.       {
  698.          labelOverride = param1;
  699.          _label = param1 != null ? param1 : resourceManager.getString("controls","label");
  700.          invalidateDisplayList();
  701.          dispatchEvent(new Event("labelChanged"));
  702.       }
  703.       
  704.       override protected function childrenCreated() : void
  705.       {
  706.          super.childrenCreated();
  707.          trackSkinChanged = true;
  708.          barSkinChanged = true;
  709.          indeterminateSkinChanged = true;
  710.       }
  711.       
  712.       private function layoutContent(param1:Number, param2:Number) : void
  713.       {
  714.          mx_internal::_track.move(0,0);
  715.          mx_internal::_track.setActualSize(param1,param2);
  716.          mx_internal::_bar.move(0,0);
  717.          mx_internal::_determinateBar.move(0,0);
  718.          mx_internal::_indeterminateBar.setActualSize(param1 + getStyle("indeterminateMoveInterval"),param2);
  719.       }
  720.       
  721.       private function _setProgress(param1:Number, param2:Number) : void
  722.       {
  723.          var _loc3_:ProgressEvent = null;
  724.          if(enabled && !isNaN(param1) && !isNaN(param2))
  725.          {
  726.             _value = param1;
  727.             _maximum = param2;
  728.             dispatchEvent(new Event(Event.CHANGE));
  729.             _loc3_ = new ProgressEvent(ProgressEvent.PROGRESS);
  730.             _loc3_.bytesLoaded = param1;
  731.             _loc3_.bytesTotal = param2;
  732.             dispatchEvent(_loc3_);
  733.             if(_indeterminate)
  734.             {
  735.                startPlayingIndeterminate();
  736.             }
  737.             if(_value == _maximum && _value > 0)
  738.             {
  739.                if(_indeterminate)
  740.                {
  741.                   stopPlayingIndeterminate();
  742.                }
  743.                if(mode != ProgressBarMode.EVENT)
  744.                {
  745.                   dispatchEvent(new Event(Event.COMPLETE));
  746.                }
  747.             }
  748.             invalidateDisplayList();
  749.          }
  750.       }
  751.       
  752.       [Bindable("labelChanged")]
  753.       public function get label() : String
  754.       {
  755.          return _label;
  756.       }
  757.       
  758.       override protected function updateDisplayList(param1:Number, param2:Number) : void
  759.       {
  760.          var _loc16_:Number = NaN;
  761.          var _loc17_:Graphics = null;
  762.          var _loc18_:Number = NaN;
  763.          super.updateDisplayList(param1,param2);
  764.          var _loc3_:Number = getStyle("horizontalGap");
  765.          var _loc4_:Number = getStyle("verticalGap");
  766.          var _loc5_:Number = getStyle("paddingLeft");
  767.          var _loc6_:Number = getStyle("paddingRight");
  768.          var _loc7_:Number = getStyle("paddingTop");
  769.          var _loc8_:Number = getStyle("paddingBottom");
  770.          var _loc9_:Number = _loc5_;
  771.          var _loc10_:Number = _loc7_;
  772.          var _loc11_:Number = getStyle("labelWidth");
  773.          var _loc12_:Number = getStyle("trackHeight");
  774.          _loc12_ = isNaN(_loc12_) ? Number(mx_internal::_track.measuredHeight) : _loc12_;
  775.          var _loc13_:TextLineMetrics = measureText(predictLabelText());
  776.          var _loc14_:Number = isNaN(_loc11_) ? _loc13_.width + UITextField.mx_internal::TEXT_WIDTH_PADDING : _loc11_;
  777.          var _loc15_:Number = _loc13_.height + UITextField.mx_internal::TEXT_HEIGHT_PADDING;
  778.          switch(labelPlacement)
  779.          {
  780.             case ProgressBarLabelPlacement.TOP:
  781.                mx_internal::_labelField.move(_loc9_,_loc10_);
  782.                mx_internal::_labelField.setActualSize(_loc14_,_loc15_);
  783.                mx_internal::_content.move(_loc9_,_loc10_ + _loc15_ + _loc4_);
  784.                layoutContent(param1 - _loc9_ - _loc6_,_loc12_);
  785.                break;
  786.             case ProgressBarLabelPlacement.RIGHT:
  787.                _loc16_ = param1 - _loc9_ - _loc6_ - _loc14_ - _loc3_;
  788.                mx_internal::_labelField.move(_loc9_ + _loc16_ + _loc3_,(param2 - _loc15_) / 2);
  789.                mx_internal::_labelField.setActualSize(_loc14_,_loc15_);
  790.                mx_internal::_content.move(_loc9_,_loc10_ + (_loc15_ - _loc12_) / 2);
  791.                layoutContent(_loc16_,_loc12_);
  792.                break;
  793.             case ProgressBarLabelPlacement.LEFT:
  794.                mx_internal::_labelField.move(_loc9_,_loc10_ + (param2 - _loc15_) / 2);
  795.                mx_internal::_labelField.setActualSize(_loc14_,_loc15_);
  796.                mx_internal::_content.move(_loc9_ + _loc14_ + _loc3_,_loc10_ + (_loc15_ - _loc12_) / 2);
  797.                layoutContent(param1 - _loc9_ - _loc14_ - _loc4_ - _loc6_,_loc12_);
  798.                break;
  799.             case ProgressBarLabelPlacement.CENTER:
  800.                mx_internal::_labelField.move((param1 - _loc14_) / 2,(param2 - _loc15_) / 2);
  801.                mx_internal::_labelField.setActualSize(_loc14_,_loc15_);
  802.                mx_internal::_content.move(_loc9_,_loc10_);
  803.                layoutContent(param1 - _loc6_,param2 - _loc8_);
  804.                break;
  805.             default:
  806.                mx_internal::_labelField.move(_loc9_,_loc10_ + _loc12_ + _loc4_);
  807.                mx_internal::_labelField.setActualSize(_loc14_,_loc15_);
  808.                mx_internal::_content.move(_loc9_,_loc10_);
  809.                layoutContent(param1 - _loc9_ - _loc6_,_loc12_);
  810.          }
  811.          if(mx_internal::_barMask)
  812.          {
  813.             mx_internal::_barMask.move(0,0);
  814.             if(FlexVersion.compatibilityVersion >= FlexVersion.VERSION_3_0)
  815.             {
  816.                mx_internal::_barMask.setActualSize(mx_internal::_track.width,mx_internal::_track.height);
  817.             }
  818.             else
  819.             {
  820.                _loc17_ = UIComponent(mx_internal::_barMask).graphics;
  821.                _loc17_.clear();
  822.                _loc17_.beginFill(16776960);
  823.                _loc17_.drawRect(1,1,mx_internal::_track.width - 2,mx_internal::_track.height - 2);
  824.                _loc17_.endFill();
  825.             }
  826.          }
  827.          mx_internal::_labelField.text = getFullLabelText();
  828.          mx_internal::_indeterminateBar.visible = _indeterminate;
  829.          if(indeterminateChanged || visibleChanged)
  830.          {
  831.             indeterminateChanged = false;
  832.             visibleChanged = false;
  833.             mx_internal::_indeterminateBar.visible = _indeterminate;
  834.             if(_indeterminate && _source == null && _mode == ProgressBarMode.EVENT && visible)
  835.             {
  836.                startPlayingIndeterminate();
  837.             }
  838.             else
  839.             {
  840.                stopPlayingIndeterminate();
  841.             }
  842.          }
  843.          if(_indeterminate)
  844.          {
  845.             mx_internal::_determinateBar.setActualSize(mx_internal::_track.width,mx_internal::_track.height);
  846.          }
  847.          else
  848.          {
  849.             _loc18_ = Math.max(0,mx_internal::_track.width * percentComplete / 100);
  850.             mx_internal::_determinateBar.setActualSize(_loc18_,mx_internal::_track.height);
  851.             mx_internal::_determinateBar.x = direction == ProgressBarDirection.RIGHT ? 0 : mx_internal::_track.width - _loc18_;
  852.          }
  853.       }
  854.       
  855.       public function set direction(param1:String) : void
  856.       {
  857.          if(param1 == ProgressBarDirection.LEFT || param1 == ProgressBarDirection.RIGHT)
  858.          {
  859.             _direction = param1;
  860.          }
  861.          invalidateDisplayList();
  862.          dispatchEvent(new Event("directionChanged"));
  863.       }
  864.    }
  865. }
  866.  
  867.